The result should be stored as std::string, there is no reason to prefill it with =, you just push_back the characters.

push_back onto strings of very large lengths can be a performance issue. Ideally the space should be just reserved, rather than filled with =.

reserve can be called if there is a perf issue. I dont think its that important here.

Can't use std::string as is because the type being unsigned char is important.

could probably use basic_string<unsigned char>, but that's more code changes for what looks like a marginal benefit

I would use the iterators directly for the loop:

for(auto it = buf.begin(); it < buf.end(); it += 3)
{
    std::size_t n = to_int(it[0]) << 16u | to_int(it[1]) << 8u | to_int(it[2]);

    ...
}

And add the to_int function to bit_cast it and convert it to std::size_t.

Actually it would be better to make a function to encode the triplet since you repeat the same below for the "padding":

template<class Input>
std::array<char, 4> encode(Input input)
{
    std::size_t n = to_int(it[0]) << 16u | to_int(it[1]) << 8u | to_int(it[2]);
    return {b64_chars.at(n >> 18u), b64_chars.at(n >> 12u & 0x3Fu), b64_chars.at(n >> 6u & 0x3Fu), b64_chars.at(n & 0x3Fu) };
}

Then the loop can do:

for(auto it = buf.begin(); it < buf.end(); it += 3)
{
    copy(encode(it), std::back_inserter(result));
}

As far as iterator usage is concerned, lt or gt comparison is not recommended against buf.end(). It should strictly be used by an equality comparison: == or !=.

As far as iterator usage is concerned, lt or gt comparison is not recommended against buf.end()

Not recommended, by who? These are random access iterators so they support comparison operators just like pointers. The < operator should definitely be used here since we are skipping over by increments of 3, which means it could skip past the end, and it would become an infinite loop since we would never reach the end as we already past it.

But it could be UB if its past buf.end() so we probably need to do buf.end() - remaining to avoid that.

You can reuse the encode function so it doesnt repeat the code. You can also copy the chars into an array(this way pad_cond is not getting sublty modified):

assert(pad_cond < 3);
std::array<char, 3> triple = {0};
// Get the remaining characters to encode
std::copy(buf.end() - pad_cond, buf.end(), triple.begin());
auto e = encode(triple);
// Add the encoded characters
std::copy(e.begin(), e.begin() + 1 + pad_cond, std::back_inserter(result));
// Pad string with `=`
result.append(3 - pad_cond, '=');

Also the variables should be inlined: EXPECT("AAAA" == migraphx::b64_encode({'\x00', '\x00', '\x00' }).